/** 
    \defgroup PDBIndex PDB Index

    This module applies M-Tree indexing to biological problems by
    phrasing these biological problems in terms of a metric space.

*/

/** \defgroup Neighborhoods Neighborhoods
    
    API to minimize the amount of work required to create a new amino
    acid neighborhood / distance function combination.

    This was developed to deal with the complexity involved in
    generating a complete amino-acid neighborhood.  We need this
    flexibility in order to further experiment with different
    distance functions and neighborhood definitions.

    The API consists largely of three callbacks.  Each of the
    submodules documents these callbacks in more detail.

    \ingroup PDBIndex 

*/
/** 
    \defgroup NeighborhoodConstructor Constructors

    These functions are intended to be used as call backs.

    The constructor is called at most once per residue in the pdb.  

    @param pdbcode  A four character array containing the PDB code for the current structure.

    @param neigh A pointer to a daliesque struct that will be overwritten by the constructor.

    @param atomStore All of the atoms are in this store.

    @param center Refers to an arbitrary atom in the 'central' amino acid
    for this neighborhood.  Do not assume that this will always be the
    first atom in the residue, or the alpha carbon, etc... The caller
    may arbitrarily choose any of the atoms in the residue.
    
    @param neighbors An array of atoms; one from each neighboring amino
    acid.  Again, make no assumptions about which atom will be passed
    in.

    @param count The maximum number of neighbors per neighborhood.
    \ingroup Neighborhoods

*/

/** 
    \defgroup CanCalculate Can Calculate Neighborhood

    Determine whether or not an amino acid can be used as the center
    of an amino acid neighborhood.  This callback will be called one
    time per residue in a pdb file.  If it returns true, then the
    constructor callback will be invoked for the corresponding
    neighborhood.

    @param store A store containing atom structs.  

    @param i The index of an atom in the relevant amino acid.  (The
    caller arbitrarily decides which atom this will be)

    \ingroup Neighborhoods
    \ingroup Callbacks
*/

/**
   \defgroup Metric Metric (distance) functions
   
   These functions are generally used as call-backs by M-Tree, but are
   also used in many other places.

   The interface for a distance function is quite simple:

   double distance(const void * a, const void * b);

   The two parameters are pointers to the data (usually structs) that
   the distance function will work on.  It returns a double that is
   the calculated distance.
   
   This function must obey the following properties for all a, b, and
   c (provided that a, b, and c are valid input to the function.)

   d(a, b) = d (b, a)

   d(a, b) >= 0

   d(a, c) <= d(a, b) + d(b, c)

   The M-Tree (and possibly some other) code expects the following:

   d(a, a) = 0

   Depending on this behavior should be considered a bug, but this
   would require extra calls to distance() in mTree, and I haven't
   come up with a reason to fix it...that is, I haven't come across a
   real-world distance function where d(a, a) != 0

*/

/** 
    \defgroup NeighborhoodDistance Neighborhood Distance

    Callbacks to calculate the distance between two amino acid
    neighborhoods.  Definition and analysis of this distance function
    is still an active area of our research.  The trick is to embed as
    much biological knowlegde into this function as possible, while
    keeping the size of the amino acid neighborhood to a minimum.

    \ingroup Neighborhoods
    \ingroup Metric
*/

/** 
    \defgroup Atom Atom

    \ingroup PDBIndex
*/

/** 
    \defgroup AA Amino Acid

    \ingroup PDBIndex
*/

/** 
    \defgroup Bond Bond

    \ingroup PDBIndex
*/
